# 考点：图
"""
题目描述
一个应用启动时，会有多个初始化任务需要执行，并且任务之间有依赖关系，例如A任务依赖B任务，那么必须在B任务执行完成之后，才能开始执行A任务。

现在给出多条任务依赖关系的规则，请输入任务的顺序执行序列，规则采用贪婪策略，即一个任务如果没有依赖的任务，则立刻开始执行，如果同时有多个任务要执行，则根据任务名称字母顺序排序。

例如: B任务依赖A任务，C任务依赖A任务，D任务依赖B任务和C任务，同时，D任务还依赖E任务。那么执行任务的顺序由先到后是:
A任务，E任务，B任务，C任务，D任务。
这里A和E任务都是没有依赖的，立即执行。

输入描述
输入参数每个元素都表示任意两个任务之间的依赖关系，输入参数中符号”->”表示依赖方向。

例如A->B表示A依赖B，多个依赖之间用单个空格分割

输出描述
输出为排序后的启动任务列表，多个任务之间用单个空格分割

示例1

输入：
A->B C->B

输出：
B A C
题解
这是一个典型的拓扑排序问题，通过建立任务之间的依赖关系图，然后按照一定规则执行任务，即先执行没有依赖的任务，然后再执行依赖于前面任务的任务。

以下是解题思路和代码大致描述：

使用两个字典，outdegree用于记录每个任务的出度（依赖它的任务数量），depend用于记录每个任务依赖的任务列表。
遍历输入的任务依赖关系，构建任务之间的依赖图，并同时维护出度信息。
利用拓扑排序的思想，循环执行以下步骤：
找到出度为0的任务，如果存在多个，按字母顺序排序。
将该任务加入结果集，并标记该任务已遍历。
更新邻居任务的出度，将它们的出度减1。
重复上述步骤，直到所有任务都被遍历。
代码使用了相应的数据结构和算法来实现这一过程，并输出最终排序后的启动任务列表。

时间复杂度：O(N + MlogM)，其中N是任务数量，M是依赖关系数量。建图和拓扑排序的过程时间复杂度为O(N + M)，排序的时间复杂度为O(MlogM)。 空间复杂度：O(N + M)，存储了任务的出度信息和依赖关系。

Java

作者：code5bug
链接：https://www.nowcoder.com/discuss/602464154787532800?sourceSSR=search
来源：牛客网
"""

'''
outdegree = dict()
depend = dict()

# 建立依赖关系，维护出度
for relation in input().split():
    # a 依赖 b
    a, b = relation.split('->')
    depend.setdefault(b, []).append(a)
    outdegree.setdefault(a, 0)
    outdegree.setdefault(b, 0)
    outdegree[a] += 1

# 拓扑排序结果
rs = []
while True:
    # 找到出度为0的节点，并将其加入结果集中
    temp = [key for key, indeg in outdegree.items() if indeg == 0]
    # 一旦出度为0的节点不存在，则退出循环
    if not temp:
        break

    temp.sort()
    for key in temp:
        rs.append(key)
        outdegree[key] = -1  # 表示已经遍历
        # 邻居节点出度 -1
        for neighbor in depend[key]:
            outdegree[neighbor] -= 1

print(" ".join(rs))
'''

'''
四、示例
输入：
B->A C->A D->B D->C D->E

输出：
A E B C D
五、题解
这个是一个有向图的拓扑排序问题
注意输入中B->A表示 B 依赖 A，不同题目这里依赖关系表示会有区别
拓扑排序关键点是邻接表和入度表来分别表示依赖关系

https://zhuanlan.zhihu.com/p/7183038981
'''

from collections import deque
from collections import defaultdict
def sort_by_dependencies(dependencies):
    # 构建图和入度表
    graph = defaultdict(list)
    in_degree = defaultdict(int)
    tasks = set()

    # 解析依赖关系
    for dep in dependencies.split():
        # A -> B 表示 A 依赖于 B
        dependent, dependency = dep.split('->')
        graph[dependency].append(dependent)
        in_degree[dependent] += 1
        tasks.update([dependent, dependency])
        if dependency not in in_degree:
            in_degree[dependency] = 0

    # 初始化队列: 入度为 0 的任务入队
    queue = deque(sorted([task for task in tasks if in_degree[task] == 0]))
    result = []

    # 拓扑排序
    while queue:
        cur = queue.popleft()
        result.append(cur)

        for neighbor in graph[cur]:
            in_degree[neighbor] -= 1
            if in_degree[neighbor] == 0:
                queue.append(neighbor)

    # 检查是否有环
    if len(result) != len(tasks):
        return "ERROR"

    return ' '.join(result)


if __name__ == '__main__':
    # 输入依赖关系 B->A C->A D->B D->C D->E
    dependencies = input()
    ordered_dependencies = sort_by_dependencies(dependencies)
    # A E B C D
    print(ordered_dependencies)